
import LocalCache from '@/utils/cache'
import { useMessageBox } from '@/hooks/message'

// 根据id获取按钮配置信息
export function getButtonInfoById (id) {
  const pageInfo = LocalCache.getCache('page')
  return pageInfo?.btnsObj[id] || null
}
/**
 * 加载模块,必须导出 default []
 * @param {*} directory 路径
 * @param {*} type 返回类型
 * @param {*} useSubdirectories 是否深度查找
 * @param {*} regExp 文件名称正则
 */

export function loadModules (context, type = 'object', regExp) {
  if (type === 'array') {
    return context.keys()
      .reduce((modules, path) => {
        if (context(path).default) {
          modules.push(context(path).default)
        }
        return modules
      }, [])
  }
  if (type === 'flattenArray') {
    return context.keys()
      .reduce((modules, path) => {
        if (context(path).default) {
          modules.push(...context(path).default)
        }
        return modules
      }, [])
  }
  if (type === 'object') {
    return context
      .keys()
      .map((key) => ({ key, name: key.match(regExp)[1] }))
      .reduce(
        (modules, { key, name }) => {
          if (context(key).default) {
            return {
              ...modules,
              [name]: context(key).default
            }
          } else {
            return modules
          }
        },
        {}
      )
  }
}

export function debounce(fn,delay=200){//fn是需要防抖的函数，delay是延迟多少毫秒执行fn
  let timer = null;
  return function (){
      if(timer){
          clearTimeout(timer);
      }
      timer=setTimeout(()=>{
          fn.apply(fn,arguments);
          timer = null;
      },delay)
  }
}

export function valueToLabel(value, options) {   
  if (Array.isArray(value)) {
    let str = []
    value.forEach(item => {
      const option = options.find(o => o.value === item);  
      str.push(option ? option.label : null)
    })
    return str.join(',')
  } else {
    let label = value
    if (Array.isArray(options)) {
      const option = options.find(o => o.value === value); 
      label =  option ? option?.label : null; 
    }
    return label  
  }
}  
  
export function labelToValue(label, options) {  
  const option = options.find(o => o.label === label);  
  return option ? option.value : null;  
} 
// 列筛选数据组装 item: 列对象  
export function initColumnFilterData(item) {
  const obj = { name: '', queryName: '', ops: 'like', val: '' }
  obj.name=item.prop
  obj.queryName=item?.queryName || ''
  // obj.ops=filterData.ops
  obj.val = item.modelValue
  obj.ops = getFilterOperation(item.editType, item.modelValue)
  return obj
}

// 客户端筛选 queryData：筛选条件对象  list 筛选数据数组
export function clientFilter(queryData, list) {
  return list.filter(item => {
    let isMatch = true
    for (let key in queryData) {
      // 如果查询条件不为空且列表项对应字段与查询条件不符，则isMatch为false
      if (queryData[key] && item[key] !== queryData[key]) {
        isMatch = false
        break
      }
    }
    return isMatch
  });
}
// table 本地数据列筛选 data: table列表数据，
export function clientColumnFilterData(data, columnItem) {
  let value = columnItem.modelValue
  // 如果筛选空值，或者空数组则直接返回原始数据 
  if (!value || value && value.length < 1) return data
  const ops = getFilterOperation(columnItem.editType, value)
  switch(ops) {
    case 'like':
      return data.filter(item => item[columnItem.prop].toString().includes(value.inputValue))
    case 'in':
      // return data.filter(item => value.includes(item[columnItem.prop]))
      return data.filter(item => {
        const itemPropArray = item[columnItem.prop];
        // 检查itemPropArray中的是否存在至少一个元素在value数组中
        return itemPropArray.some(propValue => value.includes(propValue));
      });
    case 'between':
      const [min, max] = value;
      return data.filter(item => item[columnItem.prop] >= min && item[columnItem.prop] <= max)
    case 'isBlank':
      return data.filter(item => !item[columnItem.prop])
    case 'notBlank':
      return data.filter(item => !!item[columnItem.prop])
    case 'gt':
      return data.filter(item => item[columnItem.prop] > value)
    case 'lt':
      return data.filter(item => item[columnItem.prop] < value)
    case 'ge':
      return data.filter(item => item[columnItem.prop] >= value)
    case 'le':
      return data.filter(item => item[columnItem.prop] <= value)
    case 'equals':
      return data.filter(item => item[columnItem.prop] === value)
    default:
      console.error(`Unsupported operation: ${ops}`)
      return data // 或者抛出错误
  }
}

// 根据类型获取筛选操作符 ops
export function getFilterOperation(type, val={inputValue: '', isBlank: false, notBlank: false}) {
  let ops = ''
  let tempType = type
  // 空 和 非空 这两个操作符优先级最高
  if(val?.isBlank) {
    tempType = 'isBlank'
  }
  if(val?.notBlank) {
    tempType = 'notBlank'
  }
  switch(tempType) {
    case 'input':
      ops = 'like';
      break;
    case 'select':
      ops = 'in';
      break;
    case 'number-range':
    case 'date-picker':
    case 'time-picker':
      ops = 'between'; 
      break;
    case 'isBlank':
      ops = 'isBlank';
      break;
    case 'notBlank':
      ops = 'notBlank';
      break;
    case '>': // gt大于
      ops = 'gt';
      break;
    case '<': // lt小于
      ops = 'lt';
      break;
    case '>=': // ge大于等于  
      ops = 'ge';
      break;
    case '<=': // le小于等于
      ops = 'le';
      break;
    case '==': // 等于
      ops = 'equals';
      break;
    default:
      console.error(`Unsupported editType: ${type}`);
      ops = 'like'; // 或者你可以选择抛出错误，而不是设置默认值
      break;
  }
  return ops;
}
// 获取动态筛选条件组装数据
export function getDynamicQueryParams(columns){
  const dynamicQueryArr = []
  Array.isArray(columns) &&
    columns.forEach((item) => {
      if (item.showHighSearch && item?.filterable) {
        const temp = initColumnFilterData(item)
        dynamicQueryArr.push(temp)
      }
    })
  return dynamicQueryArr
}

// 组装动态筛选，排序数据
export function getDynamicAddSortParams(columns){
  const dynamicQueryArr = []
  Array.isArray(columns) &&
      columns.forEach((item) => {
        // 排序
        if (item.sortable && item.sortValue) {
          const orderObj = {
            name: item.prop,
            queryName: item?.queryName || '',
            ops: item.sortValue,
          }
          state.query.orderbyParams.push(orderObj)
        }
        // 筛选
        if (item.showHighSearch === true) {
          if (item.editType === 'input') {
            const dynamicItem = {
              name: item.prop,
              queryName: item?.queryName || '',
              ops: 'like',
              val: [item.modelValue?.inputValue || ''],
            }
            // 空
            if (item.modelValue?.isBlank) {
              dynamicItem.ops = 'isBlank'
              state.query.dynamicParams.push(dynamicItem)
            }
            // 非空
            if (item.modelValue?.notBlank) {
              dynamicItem.ops = 'notBlank'
              state.query.dynamicParams.push(dynamicItem)
            }

            if (!item.modelValue?.notBlank && !item.modelValue?.isBlank && item.modelValue?.inputValue) {
              state.query.dynamicParams.push(dynamicItem)
            }
          }
          if (item.editType === 'select') {
            const dynamicItem = {
              name: item.prop,
              queryName: item?.queryName || '',
              ops: 'in',
              val: [item.modelValue],
            }
            // 当有值的时候再添加动态条件
            if (dynamicItem.val) state.query.dynamicParams.push(dynamicItem)
          }
        }
      })
  return dynamicQueryArr
}


// 页面搜索数据组装
export function initSearchData (type, columnsVal, columns, queryData) {
  if (type == 'sort') {
    if (columns.length === columnsVal.length) {
      for (let i = 0; i < columns.length; i++) {
        columns[i].sortValue = columnsVal[i].sortValue
      }
    }
  }
  if (type == 'filter' || type ==  'query') {
    columns = columnsVal
  }
  queryData.dynamicParams = []
  queryData.orderbyParams = []
  Array.isArray(columns) &&
    columns.forEach((item) => {
      // 排序
      if (item.sortable && item.sortValue) {
        const orderObj = {
          name: item.prop,
          queryName: item?.queryName || '',
          ops: item.sortValue,
        }
        queryData.orderbyParams.push(orderObj)
      }
      // 筛选
      if (item.showHighSearch === true) {
        if (item.editType === 'input') {
          const dynamicItem = {
            name: item.prop,
            queryName: item?.queryName || '',
            ops: 'like',
            val: [item.modelValue?.inputValue || ''],
          }
          // 空
          if (item.modelValue?.isBlank) {
            dynamicItem.ops = 'isBlank'
            queryData.dynamicParams.push(dynamicItem)
          }
          // 非空
          if (item.modelValue?.notBlank) {
            dynamicItem.ops = 'notBlank'
            queryData.dynamicParams.push(dynamicItem)
          }
          if (!item.modelValue?.notBlank && !item.modelValue?.isBlank && item.modelValue?.inputValue) {
            queryData.dynamicParams.push(dynamicItem)
          }
        }
        if (item.editType === 'select') {
          const dynamicItem = {
            name: item.prop,
            queryName: item?.queryName || '',
            ops: 'in',
            val: [item.modelValue],
          }
          // 当有值的时候再添加动态条件
          if (dynamicItem.val) queryData.dynamicParams.push(dynamicItem)
        }
      }
    })
  return {queryData: queryData, columns: columns}
}
// 搜索表单获取被折叠隐藏有值的选项个数, data: 搜索表单数据, rowNum: 显示几行, excludeValues: 排除的值
export const getHasSearchValues = (data, rowNum = 3, excludeValues  = []) => {
  let filledCount = 0
  const outKeys = ['dynamicParams', 'orderbyParams', 'size', 'current', ...excludeValues]
  // 下面是从第三项起计算常规搜索条件有值个树
  // 获取data的所有keys
  const queryKeys = Object.keys(data).filter((key) => !outKeys.includes(key))
  if (queryKeys.length < rowNum) return 0
  // 从第三项开始计算
  queryKeys.slice(rowNum-1).forEach((key) => {
    if (data[key] !== '' && data[key] !== null && data[key] !== undefined) {
      filledCount++
    }
  })
  return filledCount
}
// 根据id获取按钮配息
// export function getButtonInfoById (id, arr = buttonsList) {
//   if(!id) return null
//   for (const button of arr) {
//     if (button.buttonId === id) {
//       return button;
//     }
//   }
//   // 如果没有找到匹配的按钮，可以返回null或者抛出一个错误，根据实际需求来决定
//   return null;
// }

// export function mergeArrays(arr1= buttonsList, arr2) {
//   // 创建一个新数组以避免直接修改原数组
//   const merged = arr1.slice();
//   console.log('buttonsList------003', buttonsList, arr2)

//   // 遍历arr2，查找id匹配的项并在merged中更新或添加
//   arr2.forEach(item2 => {
//     const existingItemIndex = merged.findIndex(item1 => item1.id === item2.id);

//     // 如果找到了匹配的id，更新该项
//     if (existingItemIndex !== -1) {
//       merged[existingItemIndex] = { ...merged[existingItemIndex], ...item2 };
//     } else {
//       // 否则，将item2添加到merged中
//       merged.push(item2);
//     }
//   });

//   return merged;
// }

// 判断日期是否大于目标时间
export const checkDateDisabled = (date, targetTime) => {
  if (targetTime) {
    return date > targetTime
  }
  return false
}

export const openUrlFn=(type, rowData, url = '')=> {
  if (type === 'openUrl' && url) {
    window.open(url)
  } else if (type === 'toTask') {
    // useMessageBox().confirm(`打开链接：${location.href}/${rowData.formUrl}`, '任务查看/办理')
    window.open(`${location.origin}/${rowData.formUrl}`)
  } else if (type === 'trace') {
    let urls = 'inqu_status-0-processInstanceId=' + rowData.processInstanceId
    // useMessageBox().confirm(`打开链接：${location.href}/web/EWPI02?${urls}`, '图形监控')
    window.open(`${location.origin}/web/EWPI02?${urls}`)
  } else if (type === 'his') {
    var url = `/EWHB11?taskId="${rowData.id}&processInstanceId=${rowData.processInstanceId}&status=open`
    // useMessageBox().confirm(`打开链接：${location.href}/web${url}`, '查看委托代理履历')
    window.open(`${location.origin}/web${url}`)
  } else if (type === 'formDetail') {
    // useMessageBox().confirm(`打开链接：${location.href}/${rowData.formUrl}`, '查看表单明细')
    window.open(`${location.origin}/${rowData.formUrl}`)
  } else if (type === 'formHistory') {
    var url = `/common/FileDownloadAction.jsp?f=${rowData.path}`
    // useMessageBox().confirm(`打开链接：${location.href}${url}`, '查看表单历史')
    window.open(`${location.origin}${url}`)
  }
}